// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.wms.order.item;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.WmsOrderItem;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(WmsOrderItem.class)
@Setter
@Getter
public class WmsOrderItemSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "WmsOrderItem".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentId", "wo");
    map.put("productId", "p");
    map.put("whbId", "wb");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 父级
   */
  private Long parentId;

  /**
   * 父级 比较(eq)
   */
  private Long parentIdEq;
  /**
   * 父级 比较(neq)
   */
  private Long parentIdNeq;
  /**
   * 父级 比较(gt)
   */
  private Long parentIdGt;
  /**
   * 父级 比较(gte)
   */
  private Long parentIdGte;
  /**
   * 父级 比较(lt)
   */
  private Long parentIdLt;
  /**
   * 父级 比较(lte)
   */
  private Long parentIdLte;
  /**
   * 父级 比较(contains)
   */
  private Long parentIdContains;
  /**
   * 父级 比较(notcontains)
   */
  private Long parentIdNotcontains;
  /**
   * 父级 比较(startswith)
   */
  private Long parentIdStartswith;
  /**
   * 父级 比较(endswith)
   */
  private Long parentIdEndswith;
  /**
   * 父级 比较(isnull)
   */
  private Boolean parentIdIsnull;
  /**
   * 父级 比较(isnotnull)
   */
  private Boolean parentIdIsnotnull;
  /**
   * 父级的系统单号 比较(eq)
   */
  private String parentIdOrderNumberEq;
  /**
   * 父级的系统单号 比较(neq)
   */
  private String parentIdOrderNumberNeq;
  /**
   * 父级的系统单号 比较(gt)
   */
  private String parentIdOrderNumberGt;
  /**
   * 父级的系统单号 比较(gte)
   */
  private String parentIdOrderNumberGte;
  /**
   * 父级的系统单号 比较(lt)
   */
  private String parentIdOrderNumberLt;
  /**
   * 父级的系统单号 比较(lte)
   */
  private String parentIdOrderNumberLte;
  /**
   * 父级的系统单号 比较(contains)
   */
  private String parentIdOrderNumberContains;
  /**
   * 父级的系统单号 比较(notcontains)
   */
  private String parentIdOrderNumberNotcontains;
  /**
   * 父级的系统单号 比较(startswith)
   */
  private String parentIdOrderNumberStartswith;
  /**
   * 父级的系统单号 比较(endswith)
   */
  private String parentIdOrderNumberEndswith;
  /**
   * 父级的系统单号 比较(isnull)
   */
  private Boolean parentIdOrderNumberIsnull;
  /**
   * 父级的系统单号 比较(isnotnull)
   */
  private Boolean parentIdOrderNumberIsnotnull;

  /**
   * 父级(范围搜索)
   */
  private List<Long> parentIdInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 出库单明细id(模糊搜索)
   */
  private String wodId;

  /**
   * 出库单明细id 比较(eq)
   */
  private String wodIdEq;
  /**
   * 出库单明细id 比较(neq)
   */
  private String wodIdNeq;
  /**
   * 出库单明细id 比较(gt)
   */
  private String wodIdGt;
  /**
   * 出库单明细id 比较(gte)
   */
  private String wodIdGte;
  /**
   * 出库单明细id 比较(lt)
   */
  private String wodIdLt;
  /**
   * 出库单明细id 比较(lte)
   */
  private String wodIdLte;
  /**
   * 出库单明细id 比较(contains)
   */
  private String wodIdContains;
  /**
   * 出库单明细id 比较(notcontains)
   */
  private String wodIdNotcontains;
  /**
   * 出库单明细id 比较(startswith)
   */
  private String wodIdStartswith;
  /**
   * 出库单明细id 比较(endswith)
   */
  private String wodIdEndswith;
  /**
   * 出库单明细id 比较(isnull)
   */
  private Boolean wodIdIsnull;
  /**
   * 出库单明细id 比较(isnotnull)
   */
  private Boolean wodIdIsnotnull;

  /**
   * 出库单明细id(精确搜索)
   */
  private List<String> wodIdInList;

  /**
   * 商品
   */
  private Long productId;

  /**
   * 商品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 商品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 商品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 商品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 商品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 商品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 商品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 商品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 商品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 商品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 商品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 商品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 商品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 商品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 商品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 商品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 商品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 商品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 商品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 商品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 商品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 商品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 商品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 商品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 商品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 商品单价
   */
  private java.math.BigDecimal unitPrice;

  /**
   * 最小商品单价
   */
  private java.math.BigDecimal unitPriceMin;

  /**
   * 最大商品单价
   */
  private java.math.BigDecimal unitPriceMax;

  /**
   * 商品单价 比较(eq)
   */
  private java.math.BigDecimal unitPriceEq;
  /**
   * 商品单价 比较(neq)
   */
  private java.math.BigDecimal unitPriceNeq;
  /**
   * 商品单价 比较(gt)
   */
  private java.math.BigDecimal unitPriceGt;
  /**
   * 商品单价 比较(gte)
   */
  private java.math.BigDecimal unitPriceGte;
  /**
   * 商品单价 比较(lt)
   */
  private java.math.BigDecimal unitPriceLt;
  /**
   * 商品单价 比较(lte)
   */
  private java.math.BigDecimal unitPriceLte;
  /**
   * 商品单价 比较(contains)
   */
  private java.math.BigDecimal unitPriceContains;
  /**
   * 商品单价 比较(notcontains)
   */
  private java.math.BigDecimal unitPriceNotcontains;
  /**
   * 商品单价 比较(startswith)
   */
  private java.math.BigDecimal unitPriceStartswith;
  /**
   * 商品单价 比较(endswith)
   */
  private java.math.BigDecimal unitPriceEndswith;
  /**
   * 商品单价 比较(isnull)
   */
  private Boolean unitPriceIsnull;
  /**
   * 商品单价 比较(isnotnull)
   */
  private Boolean unitPriceIsnotnull;

  /**
   * 数量
   */
  private Integer count;

  /**
   * 最小数量
   */
  private Integer countMin;

  /**
   * 最大数量
   */
  private Integer countMax;

  /**
   * 数量 比较(eq)
   */
  private Integer countEq;
  /**
   * 数量 比较(neq)
   */
  private Integer countNeq;
  /**
   * 数量 比较(gt)
   */
  private Integer countGt;
  /**
   * 数量 比较(gte)
   */
  private Integer countGte;
  /**
   * 数量 比较(lt)
   */
  private Integer countLt;
  /**
   * 数量 比较(lte)
   */
  private Integer countLte;
  /**
   * 数量 比较(contains)
   */
  private Integer countContains;
  /**
   * 数量 比较(notcontains)
   */
  private Integer countNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Integer countStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Integer countEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean countIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean countIsnotnull;

  /**
   * 商品备注(模糊搜索)
   */
  private String customization;

  /**
   * 商品备注 比较(eq)
   */
  private String customizationEq;
  /**
   * 商品备注 比较(neq)
   */
  private String customizationNeq;
  /**
   * 商品备注 比较(gt)
   */
  private String customizationGt;
  /**
   * 商品备注 比较(gte)
   */
  private String customizationGte;
  /**
   * 商品备注 比较(lt)
   */
  private String customizationLt;
  /**
   * 商品备注 比较(lte)
   */
  private String customizationLte;
  /**
   * 商品备注 比较(contains)
   */
  private String customizationContains;
  /**
   * 商品备注 比较(notcontains)
   */
  private String customizationNotcontains;
  /**
   * 商品备注 比较(startswith)
   */
  private String customizationStartswith;
  /**
   * 商品备注 比较(endswith)
   */
  private String customizationEndswith;
  /**
   * 商品备注 比较(isnull)
   */
  private Boolean customizationIsnull;
  /**
   * 商品备注 比较(isnotnull)
   */
  private Boolean customizationIsnotnull;

  /**
   * 商品备注(精确搜索)
   */
  private List<String> customizationInList;

  /**
   * 库存成本 (总计)
   */
  private java.math.BigDecimal stockCost;

  /**
   * 最小库存成本 (总计)
   */
  private java.math.BigDecimal stockCostMin;

  /**
   * 最大库存成本 (总计)
   */
  private java.math.BigDecimal stockCostMax;

  /**
   * 库存成本 (总计) 比较(eq)
   */
  private java.math.BigDecimal stockCostEq;
  /**
   * 库存成本 (总计) 比较(neq)
   */
  private java.math.BigDecimal stockCostNeq;
  /**
   * 库存成本 (总计) 比较(gt)
   */
  private java.math.BigDecimal stockCostGt;
  /**
   * 库存成本 (总计) 比较(gte)
   */
  private java.math.BigDecimal stockCostGte;
  /**
   * 库存成本 (总计) 比较(lt)
   */
  private java.math.BigDecimal stockCostLt;
  /**
   * 库存成本 (总计) 比较(lte)
   */
  private java.math.BigDecimal stockCostLte;
  /**
   * 库存成本 (总计) 比较(contains)
   */
  private java.math.BigDecimal stockCostContains;
  /**
   * 库存成本 (总计) 比较(notcontains)
   */
  private java.math.BigDecimal stockCostNotcontains;
  /**
   * 库存成本 (总计) 比较(startswith)
   */
  private java.math.BigDecimal stockCostStartswith;
  /**
   * 库存成本 (总计) 比较(endswith)
   */
  private java.math.BigDecimal stockCostEndswith;
  /**
   * 库存成本 (总计) 比较(isnull)
   */
  private Boolean stockCostIsnull;
  /**
   * 库存成本 (总计) 比较(isnotnull)
   */
  private Boolean stockCostIsnotnull;

  /**
   * 捆绑类型
   */
  private String bundleType;

  /**
   * 捆绑类型 比较(eq)
   */
  private String bundleTypeEq;
  /**
   * 捆绑类型 比较(neq)
   */
  private String bundleTypeNeq;
  /**
   * 捆绑类型 比较(gt)
   */
  private String bundleTypeGt;
  /**
   * 捆绑类型 比较(gte)
   */
  private String bundleTypeGte;
  /**
   * 捆绑类型 比较(lt)
   */
  private String bundleTypeLt;
  /**
   * 捆绑类型 比较(lte)
   */
  private String bundleTypeLte;
  /**
   * 捆绑类型 比较(contains)
   */
  private String bundleTypeContains;
  /**
   * 捆绑类型 比较(notcontains)
   */
  private String bundleTypeNotcontains;
  /**
   * 捆绑类型 比较(startswith)
   */
  private String bundleTypeStartswith;
  /**
   * 捆绑类型 比较(endswith)
   */
  private String bundleTypeEndswith;
  /**
   * 捆绑类型 比较(isnull)
   */
  private Boolean bundleTypeIsnull;
  /**
   * 捆绑类型 比较(isnotnull)
   */
  private Boolean bundleTypeIsnotnull;

  /**
   * 捆绑类型(精确搜索)
   */
  private List<String> bundleTypeInList;

  /**
   * 捆绑产品wod_id【只有拆分子产品才有】(模糊搜索)
   */
  private String bundleWodId;

  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(eq)
   */
  private String bundleWodIdEq;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(neq)
   */
  private String bundleWodIdNeq;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(gt)
   */
  private String bundleWodIdGt;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(gte)
   */
  private String bundleWodIdGte;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(lt)
   */
  private String bundleWodIdLt;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(lte)
   */
  private String bundleWodIdLte;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(contains)
   */
  private String bundleWodIdContains;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(notcontains)
   */
  private String bundleWodIdNotcontains;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(startswith)
   */
  private String bundleWodIdStartswith;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(endswith)
   */
  private String bundleWodIdEndswith;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(isnull)
   */
  private Boolean bundleWodIdIsnull;
  /**
   * 捆绑产品wod_id【只有拆分子产品才有】 比较(isnotnull)
   */
  private Boolean bundleWodIdIsnotnull;

  /**
   * 捆绑产品wod_id【只有拆分子产品才有】(精确搜索)
   */
  private List<String> bundleWodIdInList;

  /**
   * MSKU(模糊搜索)
   */
  private String sellerSku;

  /**
   * MSKU 比较(eq)
   */
  private String sellerSkuEq;
  /**
   * MSKU 比较(neq)
   */
  private String sellerSkuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String sellerSkuGt;
  /**
   * MSKU 比较(gte)
   */
  private String sellerSkuGte;
  /**
   * MSKU 比较(lt)
   */
  private String sellerSkuLt;
  /**
   * MSKU 比较(lte)
   */
  private String sellerSkuLte;
  /**
   * MSKU 比较(contains)
   */
  private String sellerSkuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String sellerSkuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String sellerSkuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String sellerSkuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean sellerSkuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean sellerSkuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> sellerSkuInList;

  /**
   * 中文申报名(模糊搜索)
   */
  private String cnName;

  /**
   * 中文申报名 比较(eq)
   */
  private String cnNameEq;
  /**
   * 中文申报名 比较(neq)
   */
  private String cnNameNeq;
  /**
   * 中文申报名 比较(gt)
   */
  private String cnNameGt;
  /**
   * 中文申报名 比较(gte)
   */
  private String cnNameGte;
  /**
   * 中文申报名 比较(lt)
   */
  private String cnNameLt;
  /**
   * 中文申报名 比较(lte)
   */
  private String cnNameLte;
  /**
   * 中文申报名 比较(contains)
   */
  private String cnNameContains;
  /**
   * 中文申报名 比较(notcontains)
   */
  private String cnNameNotcontains;
  /**
   * 中文申报名 比较(startswith)
   */
  private String cnNameStartswith;
  /**
   * 中文申报名 比较(endswith)
   */
  private String cnNameEndswith;
  /**
   * 中文申报名 比较(isnull)
   */
  private Boolean cnNameIsnull;
  /**
   * 中文申报名 比较(isnotnull)
   */
  private Boolean cnNameIsnotnull;

  /**
   * 中文申报名(精确搜索)
   */
  private List<String> cnNameInList;

  /**
   * 英文申报名(模糊搜索)
   */
  private String enName;

  /**
   * 英文申报名 比较(eq)
   */
  private String enNameEq;
  /**
   * 英文申报名 比较(neq)
   */
  private String enNameNeq;
  /**
   * 英文申报名 比较(gt)
   */
  private String enNameGt;
  /**
   * 英文申报名 比较(gte)
   */
  private String enNameGte;
  /**
   * 英文申报名 比较(lt)
   */
  private String enNameLt;
  /**
   * 英文申报名 比较(lte)
   */
  private String enNameLte;
  /**
   * 英文申报名 比较(contains)
   */
  private String enNameContains;
  /**
   * 英文申报名 比较(notcontains)
   */
  private String enNameNotcontains;
  /**
   * 英文申报名 比较(startswith)
   */
  private String enNameStartswith;
  /**
   * 英文申报名 比较(endswith)
   */
  private String enNameEndswith;
  /**
   * 英文申报名 比较(isnull)
   */
  private Boolean enNameIsnull;
  /**
   * 英文申报名 比较(isnotnull)
   */
  private Boolean enNameIsnotnull;

  /**
   * 英文申报名(精确搜索)
   */
  private List<String> enNameInList;

  /**
   * 三方仓品名(模糊搜索)
   */
  private String thirdProductName;

  /**
   * 三方仓品名 比较(eq)
   */
  private String thirdProductNameEq;
  /**
   * 三方仓品名 比较(neq)
   */
  private String thirdProductNameNeq;
  /**
   * 三方仓品名 比较(gt)
   */
  private String thirdProductNameGt;
  /**
   * 三方仓品名 比较(gte)
   */
  private String thirdProductNameGte;
  /**
   * 三方仓品名 比较(lt)
   */
  private String thirdProductNameLt;
  /**
   * 三方仓品名 比较(lte)
   */
  private String thirdProductNameLte;
  /**
   * 三方仓品名 比较(contains)
   */
  private String thirdProductNameContains;
  /**
   * 三方仓品名 比较(notcontains)
   */
  private String thirdProductNameNotcontains;
  /**
   * 三方仓品名 比较(startswith)
   */
  private String thirdProductNameStartswith;
  /**
   * 三方仓品名 比较(endswith)
   */
  private String thirdProductNameEndswith;
  /**
   * 三方仓品名 比较(isnull)
   */
  private Boolean thirdProductNameIsnull;
  /**
   * 三方仓品名 比较(isnotnull)
   */
  private Boolean thirdProductNameIsnotnull;

  /**
   * 三方仓品名(精确搜索)
   */
  private List<String> thirdProductNameInList;

  /**
   * 三方仓SKU(模糊搜索)
   */
  private String thirdProductCode;

  /**
   * 三方仓SKU 比较(eq)
   */
  private String thirdProductCodeEq;
  /**
   * 三方仓SKU 比较(neq)
   */
  private String thirdProductCodeNeq;
  /**
   * 三方仓SKU 比较(gt)
   */
  private String thirdProductCodeGt;
  /**
   * 三方仓SKU 比较(gte)
   */
  private String thirdProductCodeGte;
  /**
   * 三方仓SKU 比较(lt)
   */
  private String thirdProductCodeLt;
  /**
   * 三方仓SKU 比较(lte)
   */
  private String thirdProductCodeLte;
  /**
   * 三方仓SKU 比较(contains)
   */
  private String thirdProductCodeContains;
  /**
   * 三方仓SKU 比较(notcontains)
   */
  private String thirdProductCodeNotcontains;
  /**
   * 三方仓SKU 比较(startswith)
   */
  private String thirdProductCodeStartswith;
  /**
   * 三方仓SKU 比较(endswith)
   */
  private String thirdProductCodeEndswith;
  /**
   * 三方仓SKU 比较(isnull)
   */
  private Boolean thirdProductCodeIsnull;
  /**
   * 三方仓SKU 比较(isnotnull)
   */
  private Boolean thirdProductCodeIsnotnull;

  /**
   * 三方仓SKU(精确搜索)
   */
  private List<String> thirdProductCodeInList;

  /**
   * 币种(模糊搜索)
   */
  private String currencyCode;

  /**
   * 币种 比较(eq)
   */
  private String currencyCodeEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyCodeNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyCodeGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyCodeGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyCodeLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyCodeLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyCodeContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyCodeNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyCodeStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyCodeEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyCodeIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyCodeIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> currencyCodeInList;

  /**
   * 分摊运费 (总计)
   */
  private java.math.BigDecimal apportionFreight;

  /**
   * 最小分摊运费 (总计)
   */
  private java.math.BigDecimal apportionFreightMin;

  /**
   * 最大分摊运费 (总计)
   */
  private java.math.BigDecimal apportionFreightMax;

  /**
   * 分摊运费 (总计) 比较(eq)
   */
  private java.math.BigDecimal apportionFreightEq;
  /**
   * 分摊运费 (总计) 比较(neq)
   */
  private java.math.BigDecimal apportionFreightNeq;
  /**
   * 分摊运费 (总计) 比较(gt)
   */
  private java.math.BigDecimal apportionFreightGt;
  /**
   * 分摊运费 (总计) 比较(gte)
   */
  private java.math.BigDecimal apportionFreightGte;
  /**
   * 分摊运费 (总计) 比较(lt)
   */
  private java.math.BigDecimal apportionFreightLt;
  /**
   * 分摊运费 (总计) 比较(lte)
   */
  private java.math.BigDecimal apportionFreightLte;
  /**
   * 分摊运费 (总计) 比较(contains)
   */
  private java.math.BigDecimal apportionFreightContains;
  /**
   * 分摊运费 (总计) 比较(notcontains)
   */
  private java.math.BigDecimal apportionFreightNotcontains;
  /**
   * 分摊运费 (总计) 比较(startswith)
   */
  private java.math.BigDecimal apportionFreightStartswith;
  /**
   * 分摊运费 (总计) 比较(endswith)
   */
  private java.math.BigDecimal apportionFreightEndswith;
  /**
   * 分摊运费 (总计) 比较(isnull)
   */
  private Boolean apportionFreightIsnull;
  /**
   * 分摊运费 (总计) 比较(isnotnull)
   */
  private Boolean apportionFreightIsnotnull;

  /**
   * 分摊运费 (单个)
   */
  private java.math.BigDecimal apportionFreightSingle;

  /**
   * 最小分摊运费 (单个)
   */
  private java.math.BigDecimal apportionFreightSingleMin;

  /**
   * 最大分摊运费 (单个)
   */
  private java.math.BigDecimal apportionFreightSingleMax;

  /**
   * 分摊运费 (单个) 比较(eq)
   */
  private java.math.BigDecimal apportionFreightSingleEq;
  /**
   * 分摊运费 (单个) 比较(neq)
   */
  private java.math.BigDecimal apportionFreightSingleNeq;
  /**
   * 分摊运费 (单个) 比较(gt)
   */
  private java.math.BigDecimal apportionFreightSingleGt;
  /**
   * 分摊运费 (单个) 比较(gte)
   */
  private java.math.BigDecimal apportionFreightSingleGte;
  /**
   * 分摊运费 (单个) 比较(lt)
   */
  private java.math.BigDecimal apportionFreightSingleLt;
  /**
   * 分摊运费 (单个) 比较(lte)
   */
  private java.math.BigDecimal apportionFreightSingleLte;
  /**
   * 分摊运费 (单个) 比较(contains)
   */
  private java.math.BigDecimal apportionFreightSingleContains;
  /**
   * 分摊运费 (单个) 比较(notcontains)
   */
  private java.math.BigDecimal apportionFreightSingleNotcontains;
  /**
   * 分摊运费 (单个) 比较(startswith)
   */
  private java.math.BigDecimal apportionFreightSingleStartswith;
  /**
   * 分摊运费 (单个) 比较(endswith)
   */
  private java.math.BigDecimal apportionFreightSingleEndswith;
  /**
   * 分摊运费 (单个) 比较(isnull)
   */
  private Boolean apportionFreightSingleIsnull;
  /**
   * 分摊运费 (单个) 比较(isnotnull)
   */
  private Boolean apportionFreightSingleIsnotnull;

  /**
   * 物流运费币种(模糊搜索)
   */
  private String logisticsFreightCurrencyCode;

  /**
   * 物流运费币种 比较(eq)
   */
  private String logisticsFreightCurrencyCodeEq;
  /**
   * 物流运费币种 比较(neq)
   */
  private String logisticsFreightCurrencyCodeNeq;
  /**
   * 物流运费币种 比较(gt)
   */
  private String logisticsFreightCurrencyCodeGt;
  /**
   * 物流运费币种 比较(gte)
   */
  private String logisticsFreightCurrencyCodeGte;
  /**
   * 物流运费币种 比较(lt)
   */
  private String logisticsFreightCurrencyCodeLt;
  /**
   * 物流运费币种 比较(lte)
   */
  private String logisticsFreightCurrencyCodeLte;
  /**
   * 物流运费币种 比较(contains)
   */
  private String logisticsFreightCurrencyCodeContains;
  /**
   * 物流运费币种 比较(notcontains)
   */
  private String logisticsFreightCurrencyCodeNotcontains;
  /**
   * 物流运费币种 比较(startswith)
   */
  private String logisticsFreightCurrencyCodeStartswith;
  /**
   * 物流运费币种 比较(endswith)
   */
  private String logisticsFreightCurrencyCodeEndswith;
  /**
   * 物流运费币种 比较(isnull)
   */
  private Boolean logisticsFreightCurrencyCodeIsnull;
  /**
   * 物流运费币种 比较(isnotnull)
   */
  private Boolean logisticsFreightCurrencyCodeIsnotnull;

  /**
   * 物流运费币种(精确搜索)
   */
  private List<String> logisticsFreightCurrencyCodeInList;

  /**
   * 领星销售出库单ID
   */
  private Integer woId;

  /**
   * 最小领星销售出库单ID
   */
  private Integer woIdMin;

  /**
   * 最大领星销售出库单ID
   */
  private Integer woIdMax;

  /**
   * 领星销售出库单ID 比较(eq)
   */
  private Integer woIdEq;
  /**
   * 领星销售出库单ID 比较(neq)
   */
  private Integer woIdNeq;
  /**
   * 领星销售出库单ID 比较(gt)
   */
  private Integer woIdGt;
  /**
   * 领星销售出库单ID 比较(gte)
   */
  private Integer woIdGte;
  /**
   * 领星销售出库单ID 比较(lt)
   */
  private Integer woIdLt;
  /**
   * 领星销售出库单ID 比较(lte)
   */
  private Integer woIdLte;
  /**
   * 领星销售出库单ID 比较(contains)
   */
  private Integer woIdContains;
  /**
   * 领星销售出库单ID 比较(notcontains)
   */
  private Integer woIdNotcontains;
  /**
   * 领星销售出库单ID 比较(startswith)
   */
  private Integer woIdStartswith;
  /**
   * 领星销售出库单ID 比较(endswith)
   */
  private Integer woIdEndswith;
  /**
   * 领星销售出库单ID 比较(isnull)
   */
  private Boolean woIdIsnull;
  /**
   * 领星销售出库单ID 比较(isnotnull)
   */
  private Boolean woIdIsnotnull;

  /**
   * 仓位
   */
  private Long whbId;

  /**
   * 仓位 比较(eq)
   */
  private Long whbIdEq;
  /**
   * 仓位 比较(neq)
   */
  private Long whbIdNeq;
  /**
   * 仓位 比较(gt)
   */
  private Long whbIdGt;
  /**
   * 仓位 比较(gte)
   */
  private Long whbIdGte;
  /**
   * 仓位 比较(lt)
   */
  private Long whbIdLt;
  /**
   * 仓位 比较(lte)
   */
  private Long whbIdLte;
  /**
   * 仓位 比较(contains)
   */
  private Long whbIdContains;
  /**
   * 仓位 比较(notcontains)
   */
  private Long whbIdNotcontains;
  /**
   * 仓位 比较(startswith)
   */
  private Long whbIdStartswith;
  /**
   * 仓位 比较(endswith)
   */
  private Long whbIdEndswith;
  /**
   * 仓位 比较(isnull)
   */
  private Boolean whbIdIsnull;
  /**
   * 仓位 比较(isnotnull)
   */
  private Boolean whbIdIsnotnull;
  /**
   * 仓位的仓位 比较(eq)
   */
  private String whbIdStorageBinEq;
  /**
   * 仓位的仓位 比较(neq)
   */
  private String whbIdStorageBinNeq;
  /**
   * 仓位的仓位 比较(gt)
   */
  private String whbIdStorageBinGt;
  /**
   * 仓位的仓位 比较(gte)
   */
  private String whbIdStorageBinGte;
  /**
   * 仓位的仓位 比较(lt)
   */
  private String whbIdStorageBinLt;
  /**
   * 仓位的仓位 比较(lte)
   */
  private String whbIdStorageBinLte;
  /**
   * 仓位的仓位 比较(contains)
   */
  private String whbIdStorageBinContains;
  /**
   * 仓位的仓位 比较(notcontains)
   */
  private String whbIdStorageBinNotcontains;
  /**
   * 仓位的仓位 比较(startswith)
   */
  private String whbIdStorageBinStartswith;
  /**
   * 仓位的仓位 比较(endswith)
   */
  private String whbIdStorageBinEndswith;
  /**
   * 仓位的仓位 比较(isnull)
   */
  private Boolean whbIdStorageBinIsnull;
  /**
   * 仓位的仓位 比较(isnotnull)
   */
  private Boolean whbIdStorageBinIsnotnull;

  /**
   * 仓位(范围搜索)
   */
  private List<Long> whbIdInList;

  /**
   * 最早订单结算时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderSettlementTimeStart;

  /**
   * 最晚订单结算时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderSettlementTimeEnd;

  /**
   * 订单结算时间 比较(eq)
   */
  private Date orderSettlementTimeEq;
  /**
   * 订单结算时间 比较(neq)
   */
  private Date orderSettlementTimeNeq;
  /**
   * 订单结算时间 比较(gt)
   */
  private Date orderSettlementTimeGt;
  /**
   * 订单结算时间 比较(gte)
   */
  private Date orderSettlementTimeGte;
  /**
   * 订单结算时间 比较(lt)
   */
  private Date orderSettlementTimeLt;
  /**
   * 订单结算时间 比较(lte)
   */
  private Date orderSettlementTimeLte;
  /**
   * 订单结算时间 比较(contains)
   */
  private Date orderSettlementTimeContains;
  /**
   * 订单结算时间 比较(notcontains)
   */
  private Date orderSettlementTimeNotcontains;
  /**
   * 订单结算时间 比较(startswith)
   */
  private Date orderSettlementTimeStartswith;
  /**
   * 订单结算时间 比较(endswith)
   */
  private Date orderSettlementTimeEndswith;
  /**
   * 订单结算时间 比较(isnull)
   */
  private Boolean orderSettlementTimeIsnull;
  /**
   * 订单结算时间 比较(isnotnull)
   */
  private Boolean orderSettlementTimeIsnotnull;

  /**
   * 配货情况
   */
  private String distributionSituation;

  /**
   * 配货情况 比较(eq)
   */
  private String distributionSituationEq;
  /**
   * 配货情况 比较(neq)
   */
  private String distributionSituationNeq;
  /**
   * 配货情况 比较(gt)
   */
  private String distributionSituationGt;
  /**
   * 配货情况 比较(gte)
   */
  private String distributionSituationGte;
  /**
   * 配货情况 比较(lt)
   */
  private String distributionSituationLt;
  /**
   * 配货情况 比较(lte)
   */
  private String distributionSituationLte;
  /**
   * 配货情况 比较(contains)
   */
  private String distributionSituationContains;
  /**
   * 配货情况 比较(notcontains)
   */
  private String distributionSituationNotcontains;
  /**
   * 配货情况 比较(startswith)
   */
  private String distributionSituationStartswith;
  /**
   * 配货情况 比较(endswith)
   */
  private String distributionSituationEndswith;
  /**
   * 配货情况 比较(isnull)
   */
  private Boolean distributionSituationIsnull;
  /**
   * 配货情况 比较(isnotnull)
   */
  private Boolean distributionSituationIsnotnull;

  /**
   * 配货情况(精确搜索)
   */
  private List<String> distributionSituationInList;

  /**
   * 参考号(模糊搜索)
   */
  private String referenceId;

  /**
   * 参考号 比较(eq)
   */
  private String referenceIdEq;
  /**
   * 参考号 比较(neq)
   */
  private String referenceIdNeq;
  /**
   * 参考号 比较(gt)
   */
  private String referenceIdGt;
  /**
   * 参考号 比较(gte)
   */
  private String referenceIdGte;
  /**
   * 参考号 比较(lt)
   */
  private String referenceIdLt;
  /**
   * 参考号 比较(lte)
   */
  private String referenceIdLte;
  /**
   * 参考号 比较(contains)
   */
  private String referenceIdContains;
  /**
   * 参考号 比较(notcontains)
   */
  private String referenceIdNotcontains;
  /**
   * 参考号 比较(startswith)
   */
  private String referenceIdStartswith;
  /**
   * 参考号 比较(endswith)
   */
  private String referenceIdEndswith;
  /**
   * 参考号 比较(isnull)
   */
  private Boolean referenceIdIsnull;
  /**
   * 参考号 比较(isnotnull)
   */
  private Boolean referenceIdIsnotnull;

  /**
   * 参考号(精确搜索)
   */
  private List<String> referenceIdInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
